home *** CD-ROM | disk | FTP | other *** search
/ Magnum One / Magnum One (Mid-American Digital) (Disc Manufacturing).iso / d12 / v10n14.arc / WINCOLOR.C < prev    next >
C/C++ Source or Header  |  1991-07-11  |  30KB  |  996 lines
  1. // wincolor.c RHS 1/25/91
  2.  
  3. #include<windows.h>
  4. #include<stdio.h>
  5. #include<mem.h>
  6. #include<string.h>
  7. #include<stdlib.h>
  8. #include<io.h>
  9.  
  10. #define SC_USER         (0xF000-1)
  11. #define SC_ABOUT        SC_USER
  12. #define SC_AUTOSAVE     SC_USER-1
  13. #define SC_AUTOLOAD     SC_USER-2
  14. #define SC_AUTOPILOT    SC_USER-3
  15. #define SC_AUTOUPDATE   SC_USER-4
  16.  
  17. #define WM_MYINIT      (WM_USER + 1)
  18. #define LastChar(s)     (s[strlen(s)-1])
  19.  
  20. #define MAXWINDOWSPARM  256
  21. #define MAXFILENAME     80
  22.  
  23. typedef struct _colorrect
  24.     {
  25.     RECT    r;
  26.     DWORD   color;
  27.     BOOL    solidonly;
  28.     } CRECT;
  29.  
  30. #define MAX_WININICOLORS    19
  31.  
  32.     // offset of first system color
  33. #define CRECTS_SYSCOLORS    2
  34.     // # of system colors
  35. #define MAX_SYSCOLORS       COLOR_ENDCOLORS+1
  36.     // offset of custom colors
  37. #define CRECTS_CUSTCOLORS   CRECTS_SYSCOLORS+19
  38.     // # of custom colors
  39. #define MAX_CUSTCOLORS      36
  40.     // # of rectangles in the dialog (on-screen)
  41. #define MAX_DLGRECTS        CRECTS_CUSTCOLORS+MAX_CUSTCOLORS
  42.     // offset of first Windows color
  43. #define CRECTS_WINCOLORS    MAX_DLGRECTS
  44.  
  45.     // size of rectangle array
  46. #define MAXRECTS    MAX_DLGRECTS+19
  47.  
  48. CRECT CRects[MAXRECTS] =
  49.     {
  50.     { 56, 3, 65, 12, 0x00ffffff, FALSE },          // selected color
  51.     { 4, 24, 46, 62, 0x00ffffff, FALSE },          // work area
  52.  
  53.     { 183,  110, 203, 117, 0x00ffffff, FALSE },    // scroll-bars
  54.     { 183,  126, 203, 133, 0x00ffffff, FALSE },    // desktop b-ground
  55.     { 70,   124, 90,  131, 0x00ffffff, FALSE },    // active titlebar
  56.     { 70,   134, 90,  141, 0x00ffffff, FALSE },    // inactive titlebar
  57.     { 161,  78,  181, 85,  0x00ffffff, TRUE  },    // menu 
  58.     { 70,   96,  90,  103, 0x00ffffff, TRUE  },    // window background
  59.     { 70,   78,  90,  85,  0x00ffffff, TRUE  },    // frame
  60.     { 161,  69,  181, 76,  0x00ffffff, TRUE  },    // menu text
  61.     { 70,   69,  90,  76,  0x00ffffff, TRUE  },    // window text
  62.     { 70,   87,  90,  94,  0x00ffffff, TRUE  },    // caption text
  63.     { 70,   105, 90,  112, 0x00ffffff, FALSE },    // active border
  64.     { 70,   114, 90,  121, 0x00ffffff, FALSE },    // inactive border
  65.     { 183,  134, 203, 141, 0x00ffffff, FALSE },    // application workspace
  66.     { 161,  87,  181, 94,  0x00ffffff, TRUE  },    // menu highlight
  67.     { 161,  96,  181, 103, 0x00ffffff, TRUE  },    // text in menu highlight
  68.     { 241,  126, 261, 133, 0x00ffffff, FALSE },    // button face
  69.     { 241,  136, 261, 143, 0x00ffffff, FALSE },    // button shadow
  70.     { 183,  118, 203, 125, 0x00ffffff, TRUE  },    // grayed text
  71.     { 241,  116, 261, 123, 0x00ffffff, TRUE  },    // button text
  72.  
  73.     { 188, 30, 197, 39, 0x00ffffff, FALSE},        // custom colors
  74.     { 201, 30, 210, 39, 0x00ffffff, FALSE},
  75.     { 214, 30, 223, 39, 0x00ffffff, FALSE},
  76.     { 227, 30, 236, 39, 0x00ffffff, FALSE},
  77.     { 240, 30, 249, 39, 0x00ffffff, FALSE},
  78.     { 253, 30, 262, 39, 0x00ffffff, FALSE},
  79.      
  80.     { 188, 42, 197, 51, 0x00ffffff, FALSE},
  81.     { 201, 42, 210, 51, 0x00ffffff, FALSE},
  82.     { 214, 42, 223, 51, 0x00ffffff, FALSE},
  83.     { 227, 42, 236, 51, 0x00ffffff, FALSE},
  84.     { 240, 42, 249, 51, 0x00ffffff, FALSE},
  85.     { 253, 42, 262, 51, 0x00ffffff, FALSE},
  86.      
  87.     { 188, 54, 197, 63, 0x00ffffff, FALSE},
  88.     { 201, 54, 210, 63, 0x00ffffff, FALSE},
  89.     { 214, 54, 223, 63, 0x00ffffff, FALSE},
  90.     { 227, 54, 236, 63, 0x00ffffff, FALSE},
  91.     { 240, 54, 249, 63, 0x00ffffff, FALSE},
  92.     { 253, 54, 262, 63, 0x00ffffff, FALSE},
  93.      
  94.     { 188, 66, 197, 75, 0x00ffffff, FALSE},
  95.     { 201, 66, 210, 75, 0x00ffffff, FALSE},
  96.     { 214, 66, 223, 75, 0x00ffffff, FALSE},
  97.     { 227, 66, 236, 75, 0x00ffffff, FALSE},
  98.     { 240, 66, 249, 75, 0x00ffffff, FALSE},
  99.     { 253, 66, 262, 75, 0x00ffffff, FALSE},
  100.      
  101.     { 188, 78, 197, 87, 0x00ffffff, FALSE},
  102.     { 201, 78, 210, 87, 0x00ffffff, FALSE},
  103.     { 214, 78, 223, 87, 0x00ffffff, FALSE},
  104.     { 227, 78, 236, 87, 0x00ffffff, FALSE},
  105.     { 240, 78, 249, 87, 0x00ffffff, FALSE},
  106.     { 253, 78, 262, 87, 0x00ffffff, FALSE},
  107.      
  108.     { 188, 90, 197, 99, 0x00ffffff, FALSE},
  109.     { 201, 90, 210, 99, 0x00ffffff, FALSE},
  110.     { 214, 90, 223, 99, 0x00ffffff, FALSE},
  111.     { 227, 90, 236, 99, 0x00ffffff, FALSE},
  112.     { 240, 90, 249, 99, 0x00ffffff, FALSE},
  113.     { 253, 90, 262, 99, 0x00ffffff, FALSE},
  114.  
  115.     { 0,0,0,0, 0x00ffffff, FALSE},                         // Windows colors
  116.     { 0,0,0,0, 0x00ffffff, FALSE},
  117.     { 0,0,0,0, 0x00ffffff, FALSE},
  118.     { 0,0,0,0, 0x00ffffff, FALSE},
  119.     { 0,0,0,0, 0x00ffffff, FALSE},
  120.     { 0,0,0,0, 0x00ffffff, FALSE},
  121.     { 0,0,0,0, 0x00ffffff, FALSE},
  122.     { 0,0,0,0, 0x00ffffff, FALSE},
  123.     { 0,0,0,0, 0x00ffffff, FALSE},
  124.     { 0,0,0,0, 0x00ffffff, FALSE},
  125.     { 0,0,0,0, 0x00ffffff, FALSE},
  126.     { 0,0,0,0, 0x00ffffff, FALSE},
  127.     { 0,0,0,0, 0x00ffffff, FALSE},
  128.     { 0,0,0,0, 0x00ffffff, FALSE},
  129.     { 0,0,0,0, 0x00ffffff, FALSE},
  130.     { 0,0,0,0, 0x00ffffff, FALSE},
  131.     { 0,0,0,0, 0x00ffffff, FALSE},
  132.     { 0,0,0,0, 0x00ffffff, FALSE},
  133.     { 0,0,0,0, 0x00ffffff, FALSE}
  134.          };
  135.  
  136. int colorIndex[19] =
  137. { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18 };
  138.  
  139. DWORD OrgColorVals[19];
  140.  
  141. #define SelectedColor           CRects[0]
  142. #define WorkArea                CRects[1]
  143.  
  144. static char szCopyRight[] = " WinColor, Copyright (C) Richard Hale Shaw, 1991 ";
  145. static char szWinColor[] = "WinColor";
  146.  
  147. static char szAbout[] = "About...";
  148. static char szAutoSave[] = "AutoSave";
  149. static char szAutoLoad[] = "AutoLoad";
  150. static char szAutoPilot[] = "AutoPilot";
  151. static char szAutoUpdate[] = "Update WIN.INI";
  152.  
  153. static char szWinColorIni[] = "WINCOLOR.INI";
  154.  
  155. BOOL Set = FALSE;
  156. BOOL AutoSave = FALSE;
  157. BOOL AutoLoad = FALSE;
  158. BOOL AutoPilot = FALSE;
  159. BOOL AutoUpdate = FALSE;
  160.  
  161. char szAppName[MAXFILENAME];
  162. HCURSOR hNormalCursor, hHourGlassCursor;
  163. HANDLE hPrev;
  164. LPSTR CmdLine;
  165. HANDLE hInst;
  166. HICON WinColorIcon;
  167. HWND WinColorDlg;
  168.  
  169. long FAR PASCAL WndProc(HWND, WORD, WORD, LONG);
  170. HANDLE FAR PASCAL MainWindowDlg(HWND hDlg, unsigned message, WORD wParam,
  171.    LONG lParam);
  172. void UpdateSystemMenu(void);
  173. void SelectColor(LONG lParam);
  174. void PaintWorkArea(LONG lParam);
  175. void _PaintWorkArea(DWORD color, BOOL paintrects);
  176. void _PaintCombo(DWORD color);
  177. void _PaintRect(CRECT *crect, DWORD color);
  178. void DlgPaint(HWND hWnd);
  179. void PaintRect(LONG lParam);
  180. void doubleRECT(RECT *r);
  181. void HScroll(WORD wParam, LONG lParam);
  182. void SetScrollValues(void);
  183. void InitArray(void);
  184. void SetColors(void);
  185. void SaveOrgColors(void);
  186. void RestoreColors(BOOL reset);
  187. void SaveColorsToIni(BOOL changecursor, BOOL savecomponentcolors);
  188. void GetColorsFromIni(void);
  189. BOOL IniFile(char *filename,WORD operation);
  190. void Autoload(void);
  191. void SetColorsFromWinColors(void);
  192. void UpdateWinIni(void);
  193. char *MakeWinDirFileName(char *filename);
  194. void _PaintSolidRect(DWORD color);
  195. BOOL FAR PASCAL DialogProc(HWND hDlg, unsigned message, WORD wParam, LONG lParam);
  196.  
  197. int PASCAL WinMain(HANDLE hInstance, HANDLE hPrevInstance,
  198.     LPSTR lpCmdLine, int nCmdShow)
  199.     {
  200.     MSG msg;
  201.     WNDCLASS wndclass;
  202.  
  203.     hPrev = hPrevInstance;
  204.     hInst = hInstance;
  205.     InitArray();        // initialize arrays and read WINCOLOR.INI
  206.     if(AutoPilot)       // if AutoPilot is on, see if any command-line parameters
  207.         {
  208.         char buf[50];
  209.         
  210.         lstrcpy(buf,lpCmdLine); // copy command-line into buf
  211.         if(!strlen(buf))        // if no command-line parameters...
  212.             {
  213.             SetColorsFromWinColors();  // ...set System Colors and get out
  214.             return 0;
  215.             }
  216.         }
  217.  
  218.     SaveOrgColors();    // initialize OrgColorVals from System Colors
  219.  
  220.     if(!hPrevInstance)    
  221.         {
  222.         wndclass.style = CS_DBLCLKS;
  223.         wndclass.lpfnWndProc = WndProc;
  224.         wndclass.cbClsExtra = 0;       
  225.         wndclass.cbWndExtra = DLGWINDOWEXTRA;       
  226.         wndclass.hInstance = hInstance;
  227.         wndclass.hIcon = WinColorIcon = LoadIcon(hInstance,szWinColor);
  228.         wndclass.hCursor = LoadCursor(NULL,IDC_ARROW);
  229.         wndclass.hbrBackground = COLOR_WINDOW+1; // 0; // GetStockObject(WHITE_BRUSH); 
  230.         wndclass.lpszMenuName =  NULL;
  231.         wndclass.lpszClassName = szWinColor;
  232.  
  233.         RegisterClass(&wndclass);
  234.         }
  235.  
  236.     hNormalCursor = LoadCursor(NULL, IDC_ARROW);
  237.     hHourGlassCursor = LoadCursor(NULL, IDC_WAIT);
  238.  
  239.     WinColorDlg = CreateDialog(hInstance,szWinColor, 0, NULL);
  240.     GetModuleFileName(GetClassWord(WinColorDlg,GCW_HMODULE),
  241.                 szAppName, MAXFILENAME-1);
  242.     ShowWindow(WinColorDlg, nCmdShow);
  243.  
  244.     while(GetMessage(&msg, NULL, 0, 0))
  245.         {
  246.         if(!WinColorDlg || !IsDialogMessage(WinColorDlg,&msg))
  247.             {
  248.             TranslateMessage(&msg);
  249.             DispatchMessage(&msg);
  250.             }
  251.         }
  252.     return (msg.wParam);
  253.     }
  254.  
  255.  
  256. #define LBUTTONDCLICK   1
  257. #define MY_LBUTTON      0xffff
  258. #define SET     253
  259. #define RESTORE 254
  260. #define SAVE    255
  261. #define HELP    256
  262.  
  263.  
  264. static HWND hRedScroll, hGreenScroll, hBlueScroll;
  265. int SolidTextControlIds[10] = { 215, 217, 219, 221, 231, 233, 235, 236, 247, 241 };
  266.  
  267. long FAR PASCAL WndProc(HWND hDlg, unsigned message, WORD wParam,
  268.    LONG lParam)
  269.     {
  270.     static BOOL LB_Dclick = FALSE;
  271.     static LONG templParam;
  272.     static BOOL init = FALSE;
  273.     static HBRUSH SolidTextBrush;
  274.  
  275.     switch(message)
  276.         {
  277.         case WM_CREATE:
  278.             WinColorDlg = hDlg;
  279.             UpdateSystemMenu();
  280.             SolidTextBrush = CreateSolidBrush(GetSysColor(COLOR_WINDOW));
  281.             SetFocus(GetDlgItem(hDlg, SET));
  282.             break;
  283.  
  284.         case WM_CTLCOLOR:
  285.             if(HIWORD(lParam) == CTLCOLOR_STATIC)
  286.                 {
  287.                 int i;
  288.                 for(i = 0; i < 10; i++)
  289.                     if(GetDlgCtrlID(LOWORD(lParam)) == SolidTextControlIds[i])
  290.                         {
  291.                         SetBkColor(wParam,GetSysColor(COLOR_WINDOW));
  292.                         SetTextColor(wParam,0x000000ff);
  293.                         UnrealizeObject(SolidTextBrush);
  294.                         return (DWORD)SolidTextBrush;
  295.                         }
  296.                 }
  297.  
  298.             if(!init && HIWORD(lParam) == CTLCOLOR_SCROLLBAR)
  299.                 {
  300.                 HWND hw = LOWORD(lParam);
  301.  
  302.                 switch(GetWindowWord(hw,GWW_ID))
  303.                     {
  304.                     case 211:
  305.                         hRedScroll = hw;
  306.                         break;
  307.                     case 212:
  308.                         hGreenScroll = hw;
  309.                         break;
  310.                     case 213:
  311.                         hBlueScroll = hw;
  312.                         break;
  313.                     }
  314.                 if(hRedScroll && hGreenScroll && hBlueScroll)
  315.                     PostMessage(hDlg,WM_MYINIT,0,0L);
  316.                 }
  317.             goto defwindowproc;
  318.  
  319.         case WM_MYINIT:
  320.             {
  321.             if(!init)
  322.                 {
  323.                 SetScrollRange(hRedScroll,SB_CTL,0,255,FALSE);
  324.                 SetScrollRange(hGreenScroll,SB_CTL,0,255,FALSE);
  325.                 SetScrollRange(hBlueScroll,SB_CTL,0,255,FALSE);
  326.                 _PaintWorkArea(WorkArea.color, FALSE);
  327.                 init = TRUE;
  328.             SetFocus(GetDlgItem(hDlg, SET));
  329.                 }
  330.             }
  331.             break;
  332.  
  333.         case WM_PAINT:
  334.             DlgPaint(hDlg);
  335.             break;
  336.  
  337.         case WM_QUERYENDSESSION:
  338.         case WM_CLOSE:
  339.             {
  340.             BOOL savecomponentcolors = FALSE;
  341.  
  342.             if(Set)
  343.                 if(AutoSave || (MessageBox(hDlg,"Save Color Changes?",szWinColor,
  344.                     MB_ICONQUESTION | MB_YESNO) == IDYES))
  345.                     {
  346.                     SaveOrgColors();
  347.                     //RestoreColors(FALSE);
  348.                     savecomponentcolors = TRUE;
  349.                     }
  350.             SetCursor(hHourGlassCursor);
  351.             SaveColorsToIni(FALSE,savecomponentcolors);
  352.             if(AutoUpdate)
  353.                 UpdateWinIni();
  354.             if(message == WM_QUERYENDSESSION)
  355.                 return 1L;
  356.             else                                // WM_CLOSE
  357.                 DestroyWindow(hDlg);
  358.             }
  359.             break;
  360.  
  361.         case WM_DESTROY:
  362.             WinColorDlg = 0;
  363.             SetCursor(hNormalCursor);
  364.             PostQuitMessage(0);
  365.             break;
  366.  
  367.         case WM_TIMER:                  // timer message
  368.             if(wParam == LBUTTONDCLICK)
  369.                 {
  370.                 KillTimer(hDlg,LBUTTONDCLICK);
  371.                 if(!LB_Dclick)
  372.                     SendMessage(hDlg,WM_LBUTTONDOWN,MY_LBUTTON,templParam);
  373.                 else
  374.                     LB_Dclick = FALSE;
  375.                 break;
  376.                 }
  377.             break;
  378.  
  379.         case WM_RBUTTONDOWN:
  380.             PaintRect(lParam);
  381.             break;
  382.             
  383.         case WM_LBUTTONDOWN: 
  384.             if(wParam == MY_LBUTTON)
  385.                 SelectColor(lParam);
  386.             else
  387.                 {
  388.                 LB_Dclick = FALSE;
  389.                 templParam = lParam;
  390.                 SetTimer(hDlg,LBUTTONDCLICK,GetDoubleClickTime(),NULL);
  391.                 }
  392.             break;
  393.  
  394.         case WM_LBUTTONDBLCLK:          // left button Double click
  395.             LB_Dclick = TRUE;
  396.             PaintWorkArea(lParam);
  397.             break;
  398.  
  399.         case WM_HSCROLL:
  400.             {
  401.             BYTE red,green,blue;
  402.  
  403.             HScroll(wParam,lParam);
  404.             red = GetScrollPos(hRedScroll,SB_CTL);
  405.             green = GetScrollPos(hGreenScroll,SB_CTL);
  406.             blue = GetScrollPos(hBlueScroll,SB_CTL);
  407.             _PaintCombo(RGB(red,green,blue));
  408.             SetScrollValues();
  409.             }
  410.             break;
  411.  
  412.         case WM_COMMAND:
  413. //            SetFocus(hDlg);
  414.             switch(wParam)
  415.                 {
  416.                 case SET:
  417.                     Set = TRUE;
  418.                     SetColors();
  419.                     return 0L;
  420.                 case RESTORE:
  421.                     RestoreColors(TRUE);
  422.                     Set = FALSE;
  423.                     return 0L;
  424.                 case SAVE:
  425.                     SaveColorsToIni(TRUE,TRUE);
  426.                     return 0L;
  427.                 case HELP:
  428.                     DialogBox(hInst, "WinColorHelp", hDlg, (FARPROC)DialogProc);
  429.                     return 0L;
  430.                 default:
  431.                     if(HIWORD(lParam) == EN_SETFOCUS)
  432.                         {
  433.                         RECT rect;
  434.                         HDC hDC = GetDC(LOWORD(lParam));
  435.                         GetClientRect(LOWORD(lParam),&rect);
  436.                         rect.top -= 2;
  437.                         rect.left -= 2;
  438.                         rect.right += 2;
  439.                         rect.bottom += 2;
  440.  
  441.                         Rectangle(hDC,rect.left,rect.top,rect.right,rect.bottom);
  442.                         ReleaseDC(LOWORD(lParam),hDC);
  443.                         }
  444.                     return 0L;
  445.                 }
  446.             break;
  447.  
  448.         case WM_INITMENU:           // modify the system menu
  449.             CheckMenuItem(GetSystemMenu(WinColorDlg,0),
  450.                 SC_AUTOSAVE,
  451.                 (MF_BYCOMMAND | (AutoSave ? MF_CHECKED : MF_UNCHECKED)));
  452.             CheckMenuItem(GetSystemMenu(WinColorDlg,0),
  453.                 SC_AUTOLOAD,
  454.                 (MF_BYCOMMAND | (AutoLoad ? MF_CHECKED : MF_UNCHECKED)));
  455.             CheckMenuItem(GetSystemMenu(WinColorDlg,0),
  456.                 SC_AUTOPILOT,
  457.                 (MF_BYCOMMAND | (AutoPilot ? MF_CHECKED : MF_UNCHECKED)));
  458.             CheckMenuItem(GetSystemMenu(WinColorDlg,0),
  459.                 SC_AUTOUPDATE,
  460.                 (MF_BYCOMMAND | (AutoUpdate ? MF_CHECKED : MF_UNCHECKED)));
  461.             break;
  462.  
  463.         case WM_SYSCOMMAND:
  464.             switch(wParam)
  465.                 {
  466.                 case SC_ABOUT:
  467.                     DialogBox(hInst, "ABOUTBOX", hDlg, (FARPROC)DialogProc);
  468.                     break;
  469.  
  470.                 case SC_AUTOLOAD:
  471.                     Autoload();
  472.                     break;
  473.  
  474.                 case SC_AUTOSAVE:
  475.                     AutoSave = !AutoSave;
  476.                     CheckMenuItem(GetSystemMenu(WinColorDlg,0),
  477.                         SC_AUTOSAVE,(MF_BYCOMMAND |
  478.                             (AutoSave ? MF_CHECKED : MF_UNCHECKED)));
  479.                     break;;
  480.  
  481.                 case SC_AUTOPILOT:
  482.                     AutoPilot = !AutoPilot;
  483.                     CheckMenuItem(GetSystemMenu(WinColorDlg,0),
  484.                         SC_AUTOPILOT,(MF_BYCOMMAND |
  485.                             (AutoPilot ? MF_CHECKED : MF_UNCHECKED)));
  486.                     break;
  487.                 case SC_AUTOUPDATE:
  488.                     AutoUpdate = !AutoUpdate;
  489.                     CheckMenuItem(GetSystemMenu(WinColorDlg,0),
  490.                         SC_AUTOUPDATE,(MF_BYCOMMAND |
  491.                             (AutoUpdate ? MF_CHECKED : MF_UNCHECKED)));
  492.                     break;
  493.  
  494.                 default:
  495.                     goto defwindowproc;
  496.                 }
  497.             break;
  498.  
  499.         default:
  500. defwindowproc:
  501.             return DefWindowProc(hDlg,message,wParam,lParam);
  502.         }
  503.     return 0L;
  504.     }
  505.  
  506.  
  507. // saves the current system colors into OrgColorVals
  508. void SaveOrgColors(void)
  509.     {
  510.     int i;
  511.  
  512.     for(i = 0; i < 19; i++)
  513.         OrgColorVals[i] = GetSysColor(i);
  514.     }
  515.  
  516. void SetColors(void)
  517.     {
  518.     int i;
  519.     DWORD ColorVals[19];
  520.     CRECT *start = &CRects[CRECTS_SYSCOLORS];
  521.  
  522.     for(i = 0; i < 19; i++, start++)
  523.         ColorVals[i] = start->color;
  524.  
  525.     SetSysColors(19,&colorIndex,&ColorVals);
  526.     }
  527.  
  528. void SetColorsFromWinColors(void)
  529.     {
  530.     int i;
  531.     DWORD ColorVals[19];
  532.     CRECT *start = &CRects[57];
  533.  
  534.     for(i = 0; i < 19; i++, start++)
  535.         ColorVals[i] = start->color;
  536.  
  537.     SetSysColors(19,&colorIndex,&ColorVals);
  538.     }
  539.  
  540. void RestoreColors(BOOL reset)
  541.     {    
  542.     int i;
  543.     CRECT *start = &CRects[CRECTS_SYSCOLORS];
  544.  
  545.     for(i = 0; i < 19; i++, start++)
  546.         start->color = OrgColorVals[i];
  547.  
  548.     if(reset)
  549.         SetSysColors(19,&colorIndex,&OrgColorVals);
  550.     }
  551.  
  552. void SaveColorsToIni(BOOL changecursor, BOOL savecomponentcolors)
  553.     {
  554.     int i,hdl;
  555.     char buf[40], *section = "[WinColor]\r\n";
  556.     char name[144];
  557.     OFSTRUCT OfStruct;
  558.  
  559.     if(changecursor)
  560.         SetCursor(hHourGlassCursor);
  561.  
  562.     strcpy(name,szWinColorIni);
  563.     MakeWinDirFileName(name);
  564.     if((hdl = OpenFile(name,&OfStruct,
  565.         OF_CREATE | OF_WRITE | OF_SHARE_DENY_WRITE)) == -1)
  566.         {
  567.         if(changecursor)
  568.             SetCursor(hNormalCursor);
  569.         sprintf(buf,"Unable to update %s",szWinColorIni);
  570.         MessageBox(WinColorDlg,buf,szWinColor,MB_ICONEXCLAMATION);
  571.         return;
  572.         }
  573.     write(hdl,section,strlen(section));
  574.     sprintf(buf,"%s=%d\r\n",szAutoSave,(AutoSave ? 1 : 0));
  575.     write(hdl,buf,strlen(buf));
  576.     sprintf(buf,"%s=%d\r\n",szAutoLoad,(AutoLoad ? 1 : 0));
  577.     write(hdl,buf,strlen(buf));
  578.     sprintf(buf,"%s=%d\r\n",szAutoPilot,(AutoPilot ? 1 : 0));
  579.     write(hdl,buf,strlen(buf));
  580.     sprintf(buf,"%s=%d\r\n",szAutoUpdate,(AutoUpdate ? 1 : 0));
  581.     write(hdl,buf,strlen(buf));
  582.  
  583.     for(i = 0; i < MAX_DLGRECTS; i++)
  584.         {
  585.         sprintf(buf,"color%02d=%010lu\r\n",i,CRects[i].color);
  586.         write(hdl,buf,strlen(buf));
  587.         }
  588.  
  589.     for( ; i < MAXRECTS; i++)
  590.         {
  591.         if(savecomponentcolors)
  592.             CRects[i].color = GetSysColor(i-57);
  593.         sprintf(buf,"color%02d=%010lu\r\n",i,CRects[i].color);
  594.         write(hdl,buf,strlen(buf));
  595.         }
  596.     _lclose(hdl);
  597.     SaveOrgColors();
  598.     Set = FALSE;
  599.     if(changecursor)
  600.         SetCursor(hNormalCursor);
  601.     }
  602.  
  603.  
  604. BOOL IniFile(char *filename,WORD operation)
  605.     {
  606.     char name[144];
  607.     OFSTRUCT OfStruct;
  608.     int hdl;
  609.  
  610.     strcpy(name,filename);
  611.     MakeWinDirFileName(name);
  612.     if((hdl = OpenFile(name,&OfStruct,operation)) == -1)
  613.         return FALSE;
  614.     _lclose(hdl);
  615.     return TRUE;
  616.     }
  617.  
  618. char *MakeWinDirFileName(char *filename)
  619.     {
  620.     char name[20];
  621.  
  622.     strcpy(name,filename);
  623.     GetWindowsDirectory(filename,144);
  624.     if(LastChar(filename) != '\\')
  625.         strcat(filename,"\\");
  626.     strcat(filename,name);
  627.     return filename;
  628.     }
  629.  
  630.  
  631. void GetColorsFromIni(void)
  632.     {    
  633.     int i;
  634.     char key[10], value[15];
  635.  
  636.     AutoSave = GetPrivateProfileInt(szWinColor,szAutoSave,0,szWinColorIni);
  637.     AutoLoad = GetPrivateProfileInt(szWinColor,szAutoLoad,0,szWinColorIni);
  638.     AutoPilot = GetPrivateProfileInt(szWinColor,szAutoPilot,0,szWinColorIni);
  639.     AutoUpdate = GetPrivateProfileInt(szWinColor,szAutoUpdate,0,szWinColorIni);
  640.  
  641.     if(IniFile(szWinColorIni,OF_EXIST))
  642.         {
  643.         char def[15];
  644.         DWORD defval;
  645.  
  646.         SetCursor(hHourGlassCursor);
  647.         for(i = 0; i < MAX_DLGRECTS; i++)
  648.             {
  649.             sprintf(key,"color%02d",i);
  650.             GetPrivateProfileString(szWinColor,key,"01677215",value,
  651.                 sizeof(value),szWinColorIni);
  652.             CRects[i].color = atol(value);
  653.             }
  654.         for( ; i < MAXRECTS; i++)
  655.             {
  656.             sprintf(key,"color%02d",i);
  657. //            defval = GetSysColor(i-MAX_DLGRECTS);
  658.             defval = GetSysColor(i-57);
  659.             sprintf(def,"%lu",defval);
  660.             GetPrivateProfileString(szWinColor,key,def,value,
  661.                 sizeof(value),szWinColorIni);
  662.             CRects[i].color = atol(value);
  663.             }
  664.         SetColorsFromWinColors();        
  665.         SetCursor(hNormalCursor);
  666.         }        
  667.     SaveOrgColors();
  668.     }
  669.  
  670. void UpdateSystemMenu(void)
  671.     {
  672.     HMENU hSysMenu = GetSystemMenu(WinColorDlg,0);
  673.  
  674.     RemoveMenu(hSysMenu, SC_MAXIMIZE, MF_BYCOMMAND);
  675.     RemoveMenu(hSysMenu, SC_SIZE, MF_BYCOMMAND);
  676.  
  677.     AppendMenu(hSysMenu, MF_SEPARATOR, 0, NULL);
  678.     AppendMenu(hSysMenu, MF_STRING, SC_ABOUT, szAbout);
  679.     AppendMenu(hSysMenu, MF_STRING, SC_AUTOSAVE, szAutoSave);
  680.     AppendMenu(hSysMenu, MF_STRING, SC_AUTOLOAD, szAutoLoad);
  681.     AppendMenu(hSysMenu, MF_STRING, SC_AUTOPILOT, szAutoPilot);
  682.     AppendMenu(hSysMenu, MF_STRING, SC_AUTOUPDATE, szAutoUpdate);
  683.     }
  684.  
  685.  
  686. // paints the Color Work Area with the color of the rectangle pointed-to
  687. void PaintWorkArea(LONG lParam)
  688.     {    
  689.     POINT point = MAKEPOINT(lParam);
  690.     int i;
  691.  
  692.     for(i = 1; i < MAX_DLGRECTS; i++)
  693.         if(PtInRect(&CRects[i].r,point))
  694.             {
  695.             _PaintWorkArea(CRects[i].color, TRUE);
  696.             break;
  697.             }
  698.     }
  699.  
  700. // paints the Color Work area the specified color and sets the scroll-bars
  701. void _PaintWorkArea(DWORD color, BOOL paintrects)
  702.     {
  703.     if(paintrects)
  704.         _PaintCombo(color);
  705.     SetScrollPos(hRedScroll,SB_CTL,GetRValue(color),TRUE);
  706.     SetScrollPos(hGreenScroll,SB_CTL,GetGValue(color),TRUE);
  707.     SetScrollPos(hBlueScroll,SB_CTL,GetBValue(color),TRUE);
  708.     SetScrollValues();
  709.     }
  710.  
  711.  
  712. void SetScrollValues(void)
  713.     {
  714.     char temp[5];
  715.  
  716.     sprintf(temp,"%03d",GetScrollPos(hRedScroll,SB_CTL));
  717.     SetDlgItemText(WinColorDlg,122,temp);
  718.  
  719.     sprintf(temp,"%03d",GetScrollPos(hGreenScroll,SB_CTL));
  720.     SetDlgItemText(WinColorDlg,123,temp);
  721.  
  722.     sprintf(temp,"%03d",GetScrollPos(hBlueScroll,SB_CTL));
  723.     SetDlgItemText(WinColorDlg,124,temp);
  724.     }
  725.  
  726.  
  727. // paints the Color Work Area and the Selected Color Rectangle
  728. void _PaintCombo(DWORD color)
  729.     {
  730.     _PaintRect(&WorkArea,color);
  731.     _PaintRect(&SelectedColor,color);
  732.     }
  733.  
  734. // paints the Selected Color Rectange the color of the rectangle pointed-to
  735. void SelectColor(LONG lParam)
  736.     {
  737.     POINT point = MAKEPOINT(lParam);
  738.     int i;
  739.  
  740.     for(i = 1; i < MAX_DLGRECTS; i++)
  741.         if(PtInRect(&CRects[i].r,point))
  742.             {
  743.             _PaintRect(&SelectedColor,CRects[i].color);
  744.             break;
  745.             }
  746.     }
  747.  
  748. // paints the pointed to rectangle the selected color
  749. void PaintRect(LONG lParam)
  750.     {
  751.     POINT point = MAKEPOINT(lParam);
  752.     int i;
  753.  
  754.     for(i = 1; i < MAX_DLGRECTS; i++)
  755.         if(PtInRect(&CRects[i].r,point))
  756.             {
  757.             _PaintRect(&(CRects[i].r),SelectedColor.color);
  758.             break;
  759.             }
  760.     }
  761.  
  762. // paints a rectangle a color
  763. void _PaintRect(CRECT *crect, DWORD color)
  764.     {
  765.     HBRUSH Old,Temp;
  766.     RECT *rect = &crect->r;
  767.     HDC hDC = GetDC(WinColorDlg);
  768.  
  769.     Temp = CreateSolidBrush((crect->solidonly ? GetNearestColor(hDC,color) :
  770.         color));
  771.     Old = SelectObject(hDC,Temp);
  772.     Rectangle(hDC,rect->left,rect->top,rect->right,rect->bottom);
  773.     SelectObject(hDC,Old);
  774.     DeleteObject(Temp);
  775.     if(crect == &SelectedColor)
  776.         _PaintSolidRect(color);
  777.     ReleaseDC(WinColorDlg,hDC);
  778.     crect->color = color;
  779.     }
  780.  
  781. // paints the rectangles in the Dialog
  782. void DlgPaint(HWND hWnd)
  783.     {
  784.     PAINTSTRUCT ps;
  785.     int i;
  786.     HDC hDC = BeginPaint(hWnd,&ps);
  787.     HBRUSH Old, Temp;
  788.     DWORD color;
  789.  
  790.     SetBkMode(hDC,TRANSPARENT);         // has to be for back ground dithering
  791.  
  792.     for(i = 0; i < MAX_DLGRECTS; i++)
  793.         {
  794.         color = (CRects[i].solidonly ? GetNearestColor(hDC,CRects[i].color)
  795.                 : CRects[i].color);
  796.         Temp = CreateSolidBrush(color);
  797.         Old = SelectObject(hDC,Temp);
  798.         Rectangle(hDC,CRects[i].r.left,CRects[i].r.top,CRects[i].r.right,
  799.             CRects[i].r.bottom);
  800.         SelectObject(hDC,Old);
  801.         DeleteObject(Temp);
  802.         }
  803.     _PaintSolidRect(CRects[0].color);
  804.     EndPaint(hWnd,&ps);
  805.     }
  806.  
  807. void doubleRECT(RECT *r)
  808.     {
  809.     r->left *= 2;
  810.     r->top *= 2;
  811.     r->right *= 2;
  812.     r->bottom *= 2;
  813.     }
  814.  
  815.    // processes color-setting horizontal scroll bars
  816. void HScroll(WORD wParam, LONG lParam)
  817.     {
  818.     HWND hsb;
  819.     short color;
  820.  
  821.     hsb = HIWORD(lParam);
  822.     color = GetScrollPos(hsb,SB_CTL);
  823.  
  824.     switch(wParam)
  825.         {
  826.         case SB_PAGEDOWN:
  827.             color += 16;       // fall thru
  828.         case SB_LINEDOWN:
  829.             color++;
  830.             break;
  831.         case SB_PAGEUP:
  832.             color -= 16;       // fall thru
  833.         case SB_LINEUP:
  834.             color--;
  835.             break;
  836.         case SB_TOP:
  837.             color = 0;
  838.             break;
  839.         case SB_BOTTOM:
  840.             color = 255;
  841.             break;
  842.         case SB_THUMBPOSITION:
  843.         case SB_THUMBTRACK:
  844.             color = LOWORD(lParam);
  845.             break;
  846.         }
  847.  
  848.     SetScrollPos(hsb,SB_CTL,color,TRUE);
  849.     }
  850.  
  851. char outbuf[MAXWINDOWSPARM];
  852.  
  853. void Autoload(void)
  854.     {
  855.     char *p;
  856.  
  857.     GetProfileString("windows","load",NULL,outbuf,sizeof(outbuf));
  858.     strupr(outbuf);
  859.  
  860.     AutoLoad = !AutoLoad;
  861.  
  862.         // if Auto Load is selected and app name is not in LOAD= list
  863.     if(AutoLoad && !strstr(outbuf,szWinColor))
  864.         {
  865.         strcpy(outbuf,szAppName);               // put WinColor in buffer
  866.         strcat(outbuf," ");                     // add blank and name to it
  867.         p = &LastChar(outbuf);                  // goto last character
  868.         p++;                                    // set to the NULL
  869.                                                 // append LOAD= list
  870.         GetProfileString("windows","load",NULL,p,sizeof(outbuf)-(p-outbuf));
  871.         WriteProfileString("windows","load",outbuf);
  872.         }
  873.         // if Auto Load is not selected and app name is in LOAD= list
  874.     if(!AutoLoad && (p = strstr(outbuf,szAppName)))
  875.         {
  876.         *p = '\0';                              // NULL at start of appname
  877.         p += strlen(szAppName);                 // move past appname
  878.         strcat(outbuf,p);                       // copy everybody up
  879.         WriteProfileString("windows","load",outbuf);
  880.         }
  881.     }
  882.  
  883.  
  884. char *WinIniKeys[MAX_WININICOLORS] =
  885.     {
  886.     "Scrollbar",
  887.     "Background",
  888.     "ActiveTitle",
  889.     "InactiveTitle",
  890.     "Menu",
  891.     "Window",
  892.     "WindowFrame",
  893.     "MenuText",
  894.     "WindowText",
  895.     "TitleText",
  896.     "ActiveBorder",
  897.     "InactiveBorder",
  898.     "AppWorkspace",
  899.     "Hilight",
  900.     "HilightText",
  901.     "ButtonFace",
  902.     "ButtonShadow",
  903.     "GrayText",
  904.     "ButtonText"
  905.     };
  906.  
  907.  
  908. void UpdateWinIni(void)
  909.     {
  910.     int i;
  911.     char buf[15];
  912.  
  913.     for(i = 0; i < MAX_WININICOLORS; i++)
  914.         {
  915.         sprintf(buf,"%d %d %d",
  916.             GetRValue(GetSysColor(i)),
  917.             GetGValue(GetSysColor(i)),
  918.             GetBValue(GetSysColor(i)));
  919.         WriteProfileString("colors",WinIniKeys[i],buf);
  920.         }
  921.     }
  922. /*
  923. [colors]
  924. Background=255 128 0
  925. AppWorkspace=255 128 192
  926. Window=255 255 255
  927. WindowText=0 0 0
  928. Menu=0 255 255
  929. MenuText=0 0 0
  930. ActiveTitle=255 0 0
  931. InactiveTitle=128 128 255
  932. TitleText=255 255 255
  933. ActiveBorder=128 0 255
  934. InactiveBorder=255 255 128
  935. WindowFrame=0 0 0
  936. Scrollbar=255 226 114
  937. */
  938.  
  939.  
  940. void _PaintSolidRect(DWORD color)
  941.     {
  942.     static RECT SolidRect = { 132, 6, 150, 24 };
  943.     HDC hDC = GetDC(WinColorDlg);
  944.     HBRUSH Temp, Old;
  945.  
  946.     DWORD x = GetNearestColor(hDC,color);
  947.     
  948.     Temp = CreateSolidBrush(x); //RGB(red,green,blue));
  949.     Old = SelectObject(hDC,Temp);
  950.     Rectangle(hDC,SolidRect.left,SolidRect.top,SolidRect.right,SolidRect.bottom);
  951.     SelectObject(hDC,Old);
  952.     DeleteObject(Temp);
  953.     ReleaseDC(WinColorDlg,hDC);
  954.     }
  955.  
  956.  
  957. BOOL FAR PASCAL DialogProc(HWND hDlg, unsigned message, WORD wParam, LONG lParam)
  958.     {
  959.     switch(message)
  960.         {
  961.         case WM_INITDIALOG:
  962.             return (TRUE);
  963.  
  964.         case WM_COMMAND:
  965.             if(wParam == IDOK || wParam == IDCANCEL)
  966.                 {
  967.                 EndDialog(hDlg, TRUE);
  968.                 return (TRUE);
  969.                 }
  970.             break;
  971.         }
  972.     return FALSE;
  973.     }
  974.  
  975.  
  976. void InitArray(void)
  977.     {
  978.     int i;
  979.     CRECT *start = &CRects[CRECTS_SYSCOLORS];
  980.  
  981.     for(i = 0; i < 19; i++, start++)
  982.         {
  983.         start->color = GetSysColor(i);
  984.         doubleRECT(&start->r);
  985.         }
  986.     for(i = 0; i < MAX_CUSTCOLORS; i++, start++)
  987.         doubleRECT(&start->r);
  988.  
  989.     doubleRECT(&SelectedColor.r);
  990.     doubleRECT(&WorkArea.r);
  991.     GetColorsFromIni();
  992.     }
  993.  
  994.  
  995.  
  996.